/**
 * 紧急修复工具 - 立即修复当前场景中的所有暗色透明材质
 */

console.log('\n🚨 紧急修复：立即处理所有暗色透明材质...\n');

const scene = window.manager?.getCurrentScene()?.scene;
if (!scene) {
    console.error('❌ 场景未加载');
} else {
    let totalFixed = 0;
    let roadLineFixed = 0;
    
    scene.traverse((obj) => {
        if (obj.isMesh && obj.material) {
            const materials = Array.isArray(obj.material) ? obj.material : [obj.material];
            
            materials.forEach((mat, index) => {
                // 检查是否为透明材质
                const isTransparent = mat.transparent || mat.alphaTest > 0 || mat.opacity < 1;
                
                if (isTransparent) {
                    // 检查颜色是否过暗
                    const isDark = mat.color.r < 0.6 && mat.color.g < 0.6 && mat.color.b < 0.6;
                    
                    if (isDark) {
                        const matName = (mat.userData?.materialName || mat.name || '').toLowerCase();
                        const meshName = (obj.name || '').toLowerCase();
                        const isRoadLine = matName.includes('马路') || matName.includes('线') || 
                                         meshName.includes('马路') || meshName.includes('线') ||
                                         matName.includes('road') || matName.includes('line');
                        
                        console.log(`🔧 修复暗色透明材质: ${obj.name} - ${mat.userData?.materialName || mat.name}`);
                        console.log(`   修复前: RGB(${mat.color.r.toFixed(3)}, ${mat.color.g.toFixed(3)}, ${mat.color.b.toFixed(3)})`);
                        console.log(`   透明设置: transparent=${mat.transparent}, alphaTest=${mat.alphaTest}`);
                        
                        // 强制设置为更亮的颜色
                        if (isRoadLine) {
                            // 马路线使用更强的补偿
                            mat.color.setRGB(1.5, 1.5, 1.5); // 超白色补偿
                            mat.transparent = false;
                            mat.alphaTest = 0.5;
                            mat.depthWrite = true;
                            mat.depthTest = true;
                            obj.renderOrder = 100;
                            roadLineFixed++;
                            console.log(`   🛣️ 马路线强化修复: 超白色 + alphaTest模式`);
                        } else {
                            // 其他透明材质
                            const avgColor = (mat.color.r + mat.color.g + mat.color.b) / 3;
                            const compensation = Math.min(3.0, 1.0 / Math.max(avgColor, 0.01));
                            
                            const newR = Math.min(2.0, mat.color.r * compensation);
                            const newG = Math.min(2.0, mat.color.g * compensation);
                            const newB = Math.min(2.0, mat.color.b * compensation);
                            
                            mat.color.setRGB(newR, newG, newB);
                            mat.transparent = true;
                            mat.alphaTest = 0;
                            mat.depthWrite = false;
                            obj.renderOrder = 999;
                            console.log(`   🌿 其他透明材质修复: RGB(${newR.toFixed(3)}, ${newG.toFixed(3)}, ${newB.toFixed(3)})`);
                        }
                        
                        mat.needsUpdate = true;
                        totalFixed++;
                        
                        console.log(`   修复后: RGB(${mat.color.r.toFixed(3)}, ${mat.color.g.toFixed(3)}, ${mat.color.b.toFixed(3)})`);
                        console.log(`   新透明设置: transparent=${mat.transparent}, alphaTest=${mat.alphaTest}`);
                        console.log('');
                    }
                }
            });
        }
    });
    
    console.log(`\n✅ 紧急修复完成！`);
    console.log(`   总修复数量: ${totalFixed}`);
    console.log(`   马路线修复: ${roadLineFixed}`);
    
    if (totalFixed > 0) {
        // 强制渲染更新
        if (window.manager && window.manager.render) {
            window.manager.render();
        }
        
        console.log(`\n🎯 如果马路线仍然是黑色，可能的原因：`);
        console.log(`   1. 贴图本身RGB通道就是纯黑色`);
        console.log(`   2. 需要更强的颜色补偿`);
        console.log(`   3. 材质混合模式问题`);
        
        console.log(`\n🔧 尝试极端修复方案...`);
        
        // 极端修复：专门针对马路线
        scene.traverse((obj) => {
            if (obj.isMesh && obj.material) {
                const materials = Array.isArray(obj.material) ? obj.material : [obj.material];
                
                materials.forEach((mat) => {
                    const matName = (mat.userData?.materialName || mat.name || '').toLowerCase();
                    const meshName = (obj.name || '').toLowerCase();
                    const isRoadLine = matName.includes('马路') || matName.includes('线') || 
                                     meshName.includes('马路') || meshName.includes('线');
                    
                    if (isRoadLine) {
                        console.log(`🚨 极端修复马路线: ${obj.name}`);
                        
                        // 极端颜色补偿
                        mat.color.setRGB(3.0, 3.0, 3.0); // 3倍白色
                        
                        // 尝试不同的透明模式
                        mat.transparent = false;
                        mat.alphaTest = 0.1; // 更低的alphaTest阈值
                        mat.depthWrite = true;
                        mat.depthTest = true;
                        
                        // 尝试修改混合模式
                        mat.blending = 1; // NormalBlending
                        
                        // 如果有贴图，尝试调整贴图设置
                        if (mat.map) {
                            mat.map.premultiplyAlpha = false;
                            mat.map.needsUpdate = true;
                        }
                        
                        mat.needsUpdate = true;
                        
                        console.log(`   极端修复: 3倍白色 + alphaTest=0.1`);
                    }
                });
            }
        });
        
        // 再次强制渲染
        if (window.manager && window.manager.render) {
            window.manager.render();
        }
        
        console.log(`\n🎯 极端修复完成！如果还是黑色，请告诉我具体的材质名称。`);
    } else {
        console.log(`\n⚠️ 未找到需要修复的暗色透明材质`);
        
        // 显示所有透明材质的状态
        console.log(`\n📋 当前所有透明材质状态：`);
        scene.traverse((obj) => {
            if (obj.isMesh && obj.material) {
                const materials = Array.isArray(obj.material) ? obj.material : [obj.material];
                materials.forEach((mat) => {
                    const isTransparent = mat.transparent || mat.alphaTest > 0 || mat.opacity < 1;
                    if (isTransparent) {
                        console.log(`   ${obj.name} - ${mat.userData?.materialName || mat.name}:`);
                        console.log(`     颜色: RGB(${mat.color.r.toFixed(3)}, ${mat.color.g.toFixed(3)}, ${mat.color.b.toFixed(3)})`);
                        console.log(`     透明: transparent=${mat.transparent}, alphaTest=${mat.alphaTest}`);
                    }
                });
            }
        });
    }
}

// 暴露到全局以便重复调用
window.emergencyFix = () => {
    eval(document.querySelector('script[data-emergency-fixer]')?.textContent || '');
};

console.log('\n💡 如需重新运行，请执行: emergencyFix()');
